MUSKOX is currently used as the core software component in the High Availability UNIX clusters where it provides availability and failover of hardware and software resources. MUSKOX is also a great choice to encode object behavior in Object-Oriented Frameworks and to build complex distributed software such as Transaction Processing systems, WEB servers, and Workflow engines. Last but not least, MUSKOX is an efficient C++ parser-generator tool.

MUSKOX partitions a software system into higher-level design declarations of the laws of state transitions, and a lower-level C++ code that takes care of the details. The MUSKOX compiler converts the declarations of the laws of state transitions into C++ programs that control the application at runtime, thereby making the design a driving part of the running application.

MUSKOX is a C++ Software Engineering Tool. At compile time it declares classes along with the states and state transition rules that direct the behavior of the objects. At runtime the rules control procedural actions determined by object states, inter-object communication, and resulting state transitions. Also, at runtime object states are explicitly available for GUIs and other tools to display and control the system's behavior.

Conceptually, MUSKOX may be split into three separate entities:

the MUSKOX metalanguage
the MUSKOX compiler
the MUSKOX Application Runtime Monitor (ARM)

Developers use the MUSKOX metalanguage to declare types, objects, states, and state transition rules; the MUSKOX compiler accepts them and automatically generates an efficient ARM that executes the application.

Object Types.
Objects with the same structure, state transition, and communication patterns are instances of user-defined types. Types may be considered a combination of a C++ class along with a set of rules that govern the behavior of the class. Multiple inheritance organizes types into a hierarchy.

State Transition Rules.
The rules that define and control object state behavior are written in the MUSKOX metalanguage. Using a set of rules in conjunction with fragments of C++ code, the MUSKOX compiler generates a highly efficient ARM. The ARM automatically executes the user declared actions in accordance with state changes controlled by the rules.

Message Passing and Synchronization.
Each object has its own independent thread of control called lifecycle. Inter-object communication of state and syncronization of lifecycles of different objects is implemented via messages and automatic state change notification.

Efficient Compilation and Runtime Environments.
The MUSKOX compiler and ARM are extremely fast and robust. Usually the ARM works with little or no overhead comparing with the hand-crafted C++ code.

MUSKOX BACKGROUND

MUSKOX and Event-Driven Systems

COMMON FEATURES:

• External events outside of the MUSKOX Framework are delivered and queued at runtime as symbols, both states and messages, encoded by numbers
  
  
• In response to events the MUSKOX Framework executes C++ programs and undergoes state transitions according to state transition rules
  
  
• The framework may generate internal events with which objects communicate between themselves and synchronize event processing

DIFFERENCES:

• The MUSKOX state transition engine uses a stack of events (the parsing stack) for such applications as transaction processing, while traditional event-driven systems are usually based on a finite state machine that keeps no history of state transitions
  
  
• The MUSKOX metalanguage still allows finite state machines if only the following kind of state transition rules is used in MUSKOX specs:
  

          newstate : currentState1 messageArrived1
                   | currentState2 messageArrived2 ...
  

• MUSKOX inheritance model permits adding new events (states and messages), state transition rules, and redefining existing rules, while event-driven systems usually allow only state machines with hierarchical states
  
  
• The MUSKOX metalanguage is a lightweight addition to C++ and may be easily extended to other programming languages, while other event-driven systems are implemented either as a fullfledged programming language, a library of subprograms, or a set of programming conventions
  
  
• The MUSKOX compiler converts states and messages into nonnegative numbers, while some other event-driven systems represent states as types or templates, and messages as subprograms

MUSKOX and Formal Languages

COMMON FEATURES:

• The MUSKOX metalanguage is a dialect of the Backus-Naur Form for defining context-free grammars where state transition rules are represented by context-free rules
  
  
• A type grammar specifies a formal language where terminals correspond to messages, and nonterminals correspond to states
  
  
• The State Transition Engine is an implementation of a LR1 parser
  
  
• The MUSKOX compiler is a LR1 parser generator that converts context-free type grammars into the numeric arrays with LR1 parsing tables
  
  

DIFFERENCES:

• In MUSKOX objects generate the flow of states and messages when parsing the same flow, while traditional parsers accept symbols without affecting the flow
  
  
• The MUSKOX compiler processes any number of context free grammars, and generates multiple parsers at compile time
  
  
• The runtime framework may execute any number of parsers simultaneously
  
  
• The MUSKOX State Transition Engine may accept both terminals (messages) and nonterminals (states)
  
  
• MUSKOX type grammars are associated with C++ classes and allow inheritance and redefinition of rules
  
  

Last Modified January 29, 1996.
All trademarks are properties of their respective owners. Copyright (C) 1996 by MASTERSYS.

3596 Pimlico Dr., Pleasanton, CA 94588 USA.

Back to home page